package 基础语法;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Vector;
import java.util.function.Consumer;

public class Lambda表达式 {
    public static void main(String[] args) {
        Integer a[] = new Integer[] { 1, 2, 30 };

        Arrays.sort(a, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });
        System.out.println(Arrays.toString(a));

        Arrays.sort(a, (Integer o1, Integer o2) -> o2 - o1);// 只有一行的情况下，最后一行默认可以作为返回值，{}可不写
        Arrays.sort(a, (o1, o2) -> o2 - o1);// 参数类型 可不写.只有一个参数，()也可也不写

        Arrays.sort(a, (Integer o1, Integer o2) -> {
            // 有且只有一个抽象方法的接口叫做函数式接口，
            // 接口上放可以加@FunctionLInterface 注解。
            // Lambda表达式只能简化函数式接口的匿名内部类写法
            // (Integer o1, Integer o2)参数列表
            // ->
            // {函数体}
            return o2 - o1;
        });
        System.out.println(Arrays.toString(a));

        swim(() -> {
            System.out.println("00");
        });

        int[] p = new int[] { 1, 2, 3, 3 };
        ArrayList<Integer> aa = new ArrayList<>();
        aa.add(1);
        aa.add(2);
        aa.add(3);
        aa.forEach(new Consumer<Integer>() {// 一个接口，带有那个注解。

            @Override
            public void accept(Integer t) {
                System.out.println(t);
            }

        });
        aa.forEach((Integer i) -> {
            System.out.println(i);
        });
        aa.forEach((i) -> {
            System.out.println(i);
        });
        aa.forEach(i -> {
            System.out.println(i);
        });
        

    }

    public static void swim(Swim swim) {
        swim.swim();
    }

}

interface Swim {// 只能是接口
    void swim();// 只能有一个
}
